#include <stdio.h>
#include <stdlib.h>
#include "MonochromeLib.h"
#include "usefull.h"
#include "Snake.h"
#define HAUT 1
#define DROITE 2
#define BAS 3
#define GAUCHE 4

char map[20][10];

int AddIn_main(int isAppli, unsigned short OptionNum)
{ 
	static int SysCallCode[] = {0xD201422B,0x60F20000,0x80010070};
	static int (*SysCall)(int R4, int R5, int R6, int R7, int FNo ) = (void*)&SysCallCode;
	int key;
	char exit;
	do
	{
		exit=jeu();
		while(IsKeyUp(KEY_CTRL_EXE) && IsKeyUp(KEY_CTRL_MENU) && !exit)GetKey(&key);
	}while(key==KEY_CTRL_EXE && !exit);

}



char jeu()
{
	char snake[200],effet[]={0,0,0,0},longueur=11,fin=0,croissance=0,type,fruit_mange=0,stop=0;
	const char temps[]={1,22,14,11};
	struct coordonnees tete={15,5},cou={14,5},queue={5,5},fruit;
	char *pointeur_effet;
	int key,i,j;
	short score=0,best_score=0;
	srand(time_getTicks());
	
	if (readFile("Snkscore","sav",(unsigned char *)&best_score))Bfile_CreateFile("\\\\fls0\\Snkscore.sav0",2);

	ML_clear_vram();
	
	for(i=0;i<=19;i++)for(j=0;j<=19;j++)map[i][j]=0;

	for(i=6;i<=16;i++)
	{
		if(i<=15)affichage_corps(i,5,DROITE);
		snake[i-6]=DROITE;
		map[i-2][4]=1;
	}

	affichage_queue(5,5,DROITE);
	affichage_tete(15,5,DROITE);
	type=generation_fruit(&fruit.x,&fruit.y);

	do
	{
		ML_display_vram();
		setFps(25-13*(effet[1]>0));

		//GetKey(&key);

		//		Déplacement du serpent :

		for(i=longueur-1;i>0;i--)snake[i]=snake[i-1];
		if(effet[3]==1 || effet[3]==6)poison(snake);
		else controle(key,snake);

		if(!croissance)
		{
			clear(queue.x,queue.y);
			map[queue.x-1][queue.y-1]=0;
			deplacement(&queue.x,&queue.y,snake[longueur-1]);		
			clear(queue.x,queue.y);
			if(snake[longueur-1]==snake[longueur-2])affichage_queue(queue.x,queue.y,snake[longueur-1]);		
			else affichage_virage_queue(queue.x,queue.y,snake[longueur-2],snake[longueur-1]);
		}
		else croissance=0;

		if(effet[0] && longueur>=4)
		{
			clear(queue.x,queue.y);
			map[queue.x-1][queue.y-1]=0;
			longueur--;
			deplacement(&queue.x,&queue.y,snake[longueur-1]);
			clear(queue.x,queue.y);
			if(snake[longueur-1]==snake[longueur-2])affichage_queue(queue.x,queue.y,snake[longueur-1]);
			else affichage_virage_queue(queue.x,queue.y,snake[longueur-2],snake[longueur-1]);
		}


		deplacement(&tete.x,&tete.y,snake[0]);
		if(!map[tete.x-1][tete.y-1] || map[tete.x-1][tete.y-1]>=10)
		{
			if(effet[2] && !(effet[2]%2))affichage_tete_combo(tete.x,tete.y,snake[0]);
			else if(effet[3])affichage_tete_assommee(tete.x,tete.y,snake[0]);
			else affichage_tete(tete.x,tete.y,snake[0]);
		}
		else
		{
			affichage_tete_assommee(tete.x,tete.y,snake[0]);
			fin=1;	
		}
		map[tete.x-1][tete.y-1]=1;
		deplacement(&cou.x,&cou.y,snake[1]);
		clear(cou.x,cou.y);
		if(snake[0]==snake[1])affichage_corps(cou.x,cou.y,snake[1]);
		else affichage_virage(cou.x,cou.y,snake[0],snake[1]);

		//		Gestion des fruits :

		if(fruit_mange>11 && score && *pointeur_effet>0)
		{
			(*pointeur_effet)--;
		}
		effet[0]=0;
		if(tete.x==fruit.x && tete.y==fruit.y)
		{
			if(score && fruit_mange!=10)*pointeur_effet=0;
			fruit_mange=type;
			if(fruit_mange!=11)longueur++;
			score+=1+2*(effet[2]>0);

			if(fruit_mange!=10)
			{
				pointeur_effet=&effet[fruit_mange-11];
				*pointeur_effet=temps[fruit_mange-11];
			}
			
			type=generation_fruit(&fruit.x,&fruit.y);
			croissance=!effet[0];
		}
	
		if(IsKeyDown(KEY_CTRL_SHIFT))
		{
			while(IsKeyDown(KEY_CTRL_SHIFT));
			while(IsKeyUp(KEY_CTRL_SHIFT) && IsKeyUp(KEY_CTRL_MENU));
			while(IsKeyDown(KEY_CTRL_SHIFT));
		}
		
		if(IsKeyDown(KEY_CTRL_MENU))stop=1;

	}while(!fin && !stop);
	
	if(!stop)
	{	
		PrintXY(37,10,"Score :  ",0);
		PrintV(82,10,score);
		PrintXY(10,20,"Meilleur score :   ",0);
		PrintV(108,20,best_score);
		if(score>best_score)
		{
			writeFile("Snkscore","sav",(unsigned char*)&score,4);
			PrintXY(23,30,"Record battu !",0);
		}
	}
	return stop;
} 




void affichage_corps(char x,char y, char element)
{
	char bitmap1[]={0,252,180,180,252,0,0,0},bitmap2[]={120,72,120,120,72,120,0,0};
	char *pointeur;
	if(!(element%2))pointeur=bitmap1;
	else pointeur=bitmap2;

	ML_bmp_8_or(pointeur,6*x-5,6*y-5);
}

void affichage_tete(char x,char y,char element)
{
	char bitmap1[]={48,120,252,252,180,120,0,0},bitmap2[]={112,184,252,252,184,112,0,0},bitmap3[]={120,180,252,252,120,48,0,0},bitmap4[]={56,116,252,252,116,56,0,0};
	char *pointeur;
	
	switch(element)
	{
		case HAUT:
		pointeur=bitmap1;
		break;
		case DROITE:
		pointeur=bitmap2;
		break;
		case BAS:
		pointeur=bitmap3;
		break;
		case GAUCHE:
		pointeur=bitmap4;
		break;
	}
	clear(x,y);
	ML_bmp_8_or(pointeur,6*x-5,6*y-5);
}

void affichage_tete_assommee(char x,char y,char element)
{
	char bitmap_tete1[]={48,120,252,252,252,120,0,0},bitmap_tete2[]={112,248,252,252,248,112,0,0},bitmap_tete3[]={120,252,252,252,120,48,0,0},bitmap_tete4[]={56,124,252,252,124,56,0,0};
	char bitmap_yeux1[]={255,255,183,207,183,255,255,255},bitmap_yeux2[]={255,175,223,223,175,255,255,255},bitmap_yeux3[]={255,183,207,183,255,255,255,255},bitmap_yeux4[]={255,215,239,239,215,255,255,255};
	char *pointeur_tete,*pointeur_yeux;

	switch(element)
	{
		case HAUT:
		pointeur_tete=bitmap_tete1;
		pointeur_yeux=bitmap_yeux1;
		break;
		case DROITE:
		pointeur_tete=bitmap_tete2;
		pointeur_yeux=bitmap_yeux2;
		break;
		case BAS:
		pointeur_tete=bitmap_tete3;
		pointeur_yeux=bitmap_yeux3;
		break;
		case GAUCHE:
		pointeur_tete=bitmap_tete4;
		pointeur_yeux=bitmap_yeux4;
		break;
	}

	ML_bmp_8_or(pointeur_tete,6*x-5,6*y-5);
	ML_bmp_8_and(pointeur_yeux,6*x-5,6*y-5);
}

void affichage_queue(char x,char y,char element)
{
	char bitmap1[]={120,72,120,120,72,48,0,0},bitmap2[]={0,124,180,180,124,0,0,0},bitmap3[]={48,72,120,120,72,120,0,0},bitmap4[]={0,248,180,180,248,0,0,0};
	char *pointeur;

	switch(element)
	{
		case HAUT:
		pointeur=bitmap1;
		break;
		case DROITE:
		pointeur=bitmap2;
		break;
		case BAS:
		pointeur=bitmap3;
		break;
		case GAUCHE:
		pointeur=bitmap4;
		break;
	}

	ML_bmp_8_or(pointeur,6*x-5,6*y-5);
}

void affichage_tete_combo(char x,char y,char element)
{
	char bitmap1[]={48,72,132,204,132,48,0,0},bitmap2[]={112,168,132,132,168,112,0,0},bitmap3[]={120,132,204,132,72,48,0,0},bitmap4[]={56,84,132,132,84,56,0,0};
	char *pointeur;

	switch(element)
	{
		case HAUT:
		pointeur=bitmap1;
		break;
		case DROITE:
		pointeur=bitmap2;
		break;
		case BAS:
		pointeur=bitmap3;
		break;
		case GAUCHE:
		pointeur=bitmap4;
		break;
	}

	ML_bmp_8_or(pointeur,6*x-5,6*y-5);
}

void affichage_virage(char x,char y,char direction1,char direction2)
{
	char bitmap1[]={120,76,116,52,28,0,0,0},bitmap2[]={0,28,52,116,76,120,0,0},bitmap3[]={0,224,176,184,200,120,0,0},bitmap4[]={120,200,184,176,224,0,0,0};
	char *pointeur;

	if((direction1==HAUT && direction2==GAUCHE) || (direction1==DROITE && direction2==BAS))pointeur=bitmap1;
	if((direction1==DROITE && direction2==HAUT) || (direction1==BAS && direction2==GAUCHE))pointeur=bitmap2;
	if((direction1==GAUCHE && direction2==HAUT) || (direction1==BAS && direction2==DROITE))pointeur=bitmap3;
	if((direction1==HAUT && direction2==DROITE) || (direction1==GAUCHE && direction2==BAS))pointeur=bitmap4;

	ML_bmp_8_or(pointeur,6*x-5,6*y-5);
}

void affichage_virage_queue(char x,char y,char direction1,char direction2)
{
	char bitmap1[]={48,72,116,52,28,0,0,0},bitmap2[]={120,72,116,52,24,0,0,0},bitmap3[]={0,24,52,116,72,120,0,0},bitmap4[]={0,28,52,116,72,48,0,0},bitmap5[]={0,224,176,184,200,48,0,0},bitmap6[]={0,96,176,184,72,120,0,0},bitmap7[]={120,72,184,176,96,0,0,0},bitmap8[]={48,200,184,176,224,0,0,0};
	char *pointeur;

	if(direction1==DROITE && direction2==BAS)pointeur=bitmap1;
	if(direction1==HAUT && direction2==GAUCHE)pointeur=bitmap2;
	if(direction1==BAS && direction2==GAUCHE)pointeur=bitmap3;
	if(direction1==DROITE && direction2==HAUT)pointeur=bitmap4;
	if(direction1==GAUCHE && direction2==HAUT)pointeur=bitmap5;
	if(direction1==BAS && direction2==DROITE)pointeur=bitmap6;
	if(direction1==HAUT && direction2==DROITE)pointeur=bitmap7;
	if(direction1==GAUCHE && direction2==BAS)pointeur=bitmap8;


	ML_bmp_8_or(pointeur,6*x-5,6*y-5);
}

void clear(char x,char y)
{
	char bitmap[]={3,3,3,3,3,3,255,255};
	ML_bmp_8_and(bitmap,6*x-5,6*y-5);
}

void deplacement(char *x,char *y,char direction)
{
	*y-=(direction==HAUT);
	*x+=(direction==DROITE);
	*y+=(direction==BAS);
	*x-=(direction==GAUCHE);
	*x=*x-20*(*x==21)+20*(!*x);
	*y=*y-10*(*y==11)+10*(!*y);
}

void controle(int key,char *direction1)
{
	signed char direction2=*direction1, difference;
	if(IsKeyDown(KEY_CTRL_UP))direction2=HAUT;
	if(IsKeyDown(KEY_CTRL_RIGHT))direction2=DROITE;
	if(IsKeyDown(KEY_CTRL_DOWN))direction2=BAS;
	if(IsKeyDown(KEY_CTRL_LEFT))direction2=GAUCHE;
	difference=*direction1-direction2;
	if(difference!=2 && difference!=-2)*direction1=direction2;
}

void poison(char *direction1)
{
	signed char direction2, difference;
	do
	{
		direction2=alea(1,4);
		difference=*direction1-direction2;
	}while(!(difference%2));
	
	*direction1=direction2;
}

char generation_fruit(char *x,char *y)
{
	char fruit_simple[]={0,48,72,72,48,0,0,0},fruit_degeneratif[]={0,48,120,120,48,0,0,0},fruit_booster[]={0,16,112,56,32,0,0,0},fruit_combo[]={0,56,104,88,112,0,0,0},fruit_empoisonne[]={0,72,48,48,72,0,0,0};
	char *pointeur,type=alea(10,14);

	switch(type)
	{	
		case 10:
		pointeur=fruit_simple;	//Aucun effet spécial
		break;
		case 11:
		pointeur=fruit_degeneratif;		//Fait rapetir le serpent au lieu de le faire grandir
		break;
		case 12:
		pointeur=fruit_booster;	//Double la vitesse du serpent !
		break;
		case 13:
		pointeur=fruit_combo;	//Octroie un bonus de 2 points si le prochain fruit est mangé durant le temps imparti
		break;
		case 14:
		pointeur=fruit_empoisonne;	//Le serpent va dans des directions aléatoires pendant un certain temps
		break;
	}

	do
	{
		*x=alea(1,20);
		*y=alea(1,10);
	}while(map[*x-1][*y-1]);
	
	ML_bmp_8_or(pointeur,6**x-5,6**y-5);
	return type;
}

int alea(int min,int max)
{
	return (rand()%(max-min+1))+min;
}


int readFile(unsigned char* name,unsigned char* extension,unsigned char* reception)
{
	unsigned short filename[20]={'\\','\\','f','l','s','0','\\'};
	int a = 0;
	int handle;
	do
        {
	    filename[7+a]=name[a];
	    a++;
        }while(name[a] != 0);

	filename[7+a] = '.';
	filename[8+a] = extension[0];
	filename[9+a] = extension[1];
	filename[10+a] = extension[2];
	filename[11+a] = 0;

	handle = Bfile_OpenFile(filename,_OPENMODE_READ);
	if(handle>-1)
        {
    		Bfile_ReadFile(handle,reception,Bfile_GetFileSize(handle),0);
    		Bfile_CloseFile(handle);
    		return 1;
   	 }
	return 0;
}



int writeFile(unsigned char* name,unsigned char* extension,unsigned char* source,int taille)
{
	FONTCHARACTER filename[20]={'\\','\\','f','l','s','0','\\'};
	int a = 0;
	int handle;
	do
        {
  	 	 filename[7+a]=name[a];
        	  a++;
         }while(name[a] != 0 || a<7);

	filename[7+a] = '.';
	filename[8+a] = extension[0];
	filename[9+a] = extension[1];
	filename[10+a] = extension[2];
	filename[11+a] = 0;

	Bfile_DeleteFile(filename);
	Bfile_CreateFile(filename,taille);
	handle = Bfile_OpenFile(filename,_OPENMODE_WRITE);
	if(handle>-1)
       {
 	   Bfile_WriteFile(handle,source,taille);
  	   Bfile_CloseFile(handle);
 	   return 1;
       }
	return 0;
}



#pragma section _BR_Size
unsigned long BR_Size;
#pragma section 


#pragma section _TOP

int InitializeSystem(int isAppli, unsigned short OptionNum)
{ 
	return INIT_ADDIN_APPLICATION(isAppli, OptionNum);
}

#pragma section